import config from '@/config';
import { useUserStore } from '@/store/user';

// WebSocket 实例
let socketTask = null;
// 重连锁，防止多次重连
let isReconnecting = false;
// 单例音频实例管理
let globalAudioContext = null;
let isPlaying = false;

// 建立WebSocket连接
const connect = () => {
    // 如果已经连接或正在连接，则直接返回，防止重复连接
    if (socketTask) {
        console.log('WebSocket 已连接，无需重复操作');
        return;
    }
    if (isReconnecting) {
        console.log('WebSocket 正在重连中，请稍后...');
        return;
    }
    const userStore = useUserStore();
    const deliveryId = userStore.deliveryId;

    if (!deliveryId) {
        console.error('获取配送员ID失败，无法连接WebSocket');
        return;
    }

    // 配送端后端服务的WebSocket端点
    const wsURL = config.wsURL;
    
    socketTask = uni.connectSocket({
        url: wsURL,
        fail: (err) => {
            console.error('WebSocket 连接请求发送失败', err);
        }
    });

    // 监听WebSocket连接打开事件
    socketTask.onOpen(() => {
        console.log('WebSocket 连接已打开');
        console.log('配送员ID: ' + deliveryId);
        isReconnecting = false; // 连接成功后重置重连标志

        // 发送配送员连接消息
        console.log('发送配送员连接消息...');
        
        socketTask.send({
            data: JSON.stringify({
                type: 'delivery_connect',
                deliveryId: deliveryId,
                timestamp: new Date().toISOString()
            })
        });
        
        // 启动原生WebSocket心跳机制
        startNativeHeartbeat();
        
        // 监听WebSocket消息
        socketTask.onMessage((res) => {
            console.log('WebSocket 收到原始消息: ', res.data);
            try {
                const message = JSON.parse(res.data);
                console.log('解析后的消息: ', message);
                
                // 处理不同类型的消息
                if (message.type === 'meal_ready') {
                    console.log('收到出餐通知: ', message);
                    uni.showToast({
                        title: message.content || '有订单已出餐，请及时取餐',
                        icon: 'none',
                        duration: 5000
                    });
                    playNotificationSound();
                } else if (message.type === 'heartbeat_response') {
                    console.log('收到心跳响应: ', message);
                } else if (message.type === 'delivery_connect_response') {
                    console.log('配送员连接成功: ', message.content);
                } else if (message.type === 'connection') {
                    console.log('WebSocket连接确认: ', message.content);
                } else if (message.type === 'system_notification') {
                    console.log('收到系统通知: ', message.content);
                    uni.showToast({
                        title: message.content || '系统通知',
                        icon: 'none',
                        duration: 3000
                    });
                } else if (message.type === 'order_status_change') {
                    console.log('收到订单状态变更: ', message);
                    // 发送全局事件
                    uni.$emit('orderStatusChanged', message);
                } else {
                    console.log('收到其他类型消息: ', message);
                }
            } catch (e) {
                console.log('收到非JSON格式消息: ', res.data);
            }
        });
    });

    socketTask.onClose((res) => {
        console.log('WebSocket 连接已关闭', res);
        cleanupAndReconnect();
    });

    socketTask.onError((err) => {
        console.error('WebSocket 连接发生错误', err);
        cleanupAndReconnect();
    });
};

// 播放通知声音
const playNotificationSound = () => {
    // 防止重叠播放
    if (isPlaying) {
        console.log('音频正在播放中，跳过本次播放');
        return;
    }
    
    // 彻底清理旧实例
    const cleanupOldInstance = () => {
        if (globalAudioContext) {
            try {
                // 移除所有事件监听器
                globalAudioContext.offError();
                globalAudioContext.offPlay();
                globalAudioContext.offEnded();
                globalAudioContext.offStop();
                globalAudioContext.offCanplay();
                
                // 销毁音频上下文
                if (typeof globalAudioContext.destroy === 'function') {
                    globalAudioContext.destroy();
                }
            } catch (error) {
                console.log('清理旧音频实例失败:', error);
            } finally {
                globalAudioContext = null;
                isPlaying = false;
            }
        }
    };
    
    // 清理旧实例
    cleanupOldInstance();
    
    try {
        // 创建新的音频实例
        globalAudioContext = uni.createInnerAudioContext();
        
        globalAudioContext.src = config.notificationSound;
        globalAudioContext.autoplay = true;
        
        // 设置播放状态
        isPlaying = true;
        
        // 统一的清理函数
        const cleanup = () => {
            if (globalAudioContext) {
                try {
                    // 移除所有事件监听器
                    globalAudioContext.offError();
                    globalAudioContext.offPlay();
                    globalAudioContext.offEnded();
                    globalAudioContext.offStop();
                    globalAudioContext.offCanplay();
                    
                    // 销毁音频上下文
                    if (typeof globalAudioContext.destroy === 'function') {
                        globalAudioContext.destroy();
                    }
                } catch (error) {
                    console.log('音频上下文销毁失败:', error);
                } finally {
                    globalAudioContext = null;
                    isPlaying = false;
                }
            }
        };
        
        // 错误处理
        globalAudioContext.onError((err) => {
            console.log('音频播放失败', err);
            cleanup();
            // 音频播放失败时显示文字提示
            uni.showToast({
                title: '出餐通知',
                icon: 'none',
                duration: 2000
            });
        });
        
        // 播放成功
        globalAudioContext.onPlay(() => {
            console.log('音频播放成功');
        });
        
        // 播放结束
        globalAudioContext.onEnded(() => {
            console.log('音频播放结束');
            cleanup();
        });
        
        // 播放停止
        globalAudioContext.onStop(() => {
            console.log('音频播放停止');
            cleanup();
        });
        
        // 音频准备就绪时手动播放（双重保险）
        globalAudioContext.onCanplay(() => {
            try {
                globalAudioContext.play();
            } catch (error) {
                console.log('手动播放失败:', error);
            }
        });
        

        // 播放失败检测
        setTimeout(() => {
            if (isPlaying && globalAudioContext) {
                try {
                    // 如果autoplay失败，手动播放
                    globalAudioContext.play();
                } catch (error) {
                    console.log('延迟播放失败:', error);
                    cleanup();
                }
            }
        }, 1000); // 1秒后检查播放状态
        
    } catch (error) {
        console.log('创建音频实例失败:', error);
        isPlaying = false;
        // 创建失败时显示文字提示
        uni.showToast({
            title: '出餐通知',
            icon: 'none',
            duration: 2000
        });
    }
};

// 发送消息
const send = (message) => {
    if (!socketTask) {
        console.warn('WebSocket 未连接，无法发送消息');
        return false;
    }

    const data = typeof message === 'string' ? message : JSON.stringify(message);
    
    socketTask.send({
        data: data,
        success: () => {
            console.log('WebSocket 消息发送成功:', data);
        },
        fail: (error) => {
            console.error('WebSocket 消息发送失败:', error);
        }
    });
    
    return true;
};

// 关闭WebSocket连接
const close = () => {
    if (socketTask) {
        stopHeartbeat();
        socketTask.close({
            code: 1000,
            reason: '主动关闭'
        });
        socketTask = null;
        console.log('WebSocket 连接已主动关闭');
    }
};

// 心跳定时器
let timer = null;

const startNativeHeartbeat = () => {
    timer = setInterval(() => {
        if (socketTask) {
            // 发送原生WebSocket心跳消息
            socketTask.send({
                data: JSON.stringify({
                    type: 'heartbeat',
                    deliveryId: useUserStore().deliveryId,
                    timestamp: new Date().toISOString()
                })
            });
            console.log('发送原生WebSocket心跳消息');
        } else {
            console.log('WebSocket连接已断开，停止心跳');
            reconnect();
        }
    }, 30000); // 每30秒发送一次心跳
};

const startHeartbeat = () => {
    // 保持兼容性，调用新的原生心跳方法
    startNativeHeartbeat();
};

const stopHeartbeat = () => {
    if (timer) {
        clearInterval(timer);
        timer = null;
    }
};

const reconnect = () => {
    cleanupAndReconnect();
};

const cleanupAndReconnect = () => {
    if (isReconnecting) {
        return;
    }
    isReconnecting = true;
    console.log('清理旧连接并准备重连...');
    
    stopHeartbeat();
    if (socketTask) {
        socketTask.close();
        socketTask = null;
    }

    setTimeout(() => {
        console.log('尝试重新连接WebSocket...');
        isReconnecting = false; // 在发起下一次连接前重置标志
        connect();
    }, 5000); // 5秒后重连
};

const disconnect = () => {
    stopHeartbeat();
    if (socketTask) {
        socketTask.close();
        socketTask = null;
    }
    console.log('手动断开WebSocket连接');
};

export {
    connect,
    disconnect
};